<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <!-- JS中数据类型 分为基本数据类型和引用数据类型
    在引用数据类型发生改变时通常是浅拷贝（不考虑特殊改变形式下）
    -->
    <!-- JS中数据类型 通常分为基本数据类型和引用数据类型
    在引用数据类型发生改变时通常是浅拷贝(不考虑特殊改变形式下)
     -->
    <!--  
        JS中数据类型 分为基本数据类型和引用数据类型
        在引用数据类型发生改变时通常是浅拷贝(不考虑特殊改变形式下)
    -->
    <script>
        let a = {
                a: 1,
                b: {
                    c: 2,
                    d: {
                        a: [
                            1, 2, 3, 4, 5, {
                                k: 1,
                                c: 0,
                                e: [
                                    2, 3, 4, 5, 6, 8, {
                                        a: 1,
                                        b: 2,
                                        r: 1
                                    }
                                ]
                            }
                        ]
                    }
                }
            }
            // var b=JSON.parse(JSON.stringify(a));
            // b.b.d.a[5].c=1;
            // console.log(a)
        let xuexiwei = [];;
        //xuexiwei[1]
        function tuzi(index) {
            if (index < 2) {
                xuexiwei[index] = 1
            } else {
                xuexiwei[index] = xuexiwei[index - 1] + xuexiwei[index - 2]
            }
            if (index < 49) {
                tuzi(index + 1)
            }
            //[1,1]
        }
        tuzi(0)
        console.log(xuexiwei);
        //深拷贝 之  递归拷贝
        var b = deepClone(a);
        b.b.c = 1;
        console.log(b);
        console.log(a);

        function deepClone(obj) {
            // Array.isArray()
            // 判断是不是数组
            var objClone = Array.isArray(obj) ? [] : {};
            //判断当前obj是不是存在的null undefind
            if (obj && typeof(obj) == "object") {
                //循环当前的对象
                for (let key in obj) {
                    //判断当前对象有没有下标 如果没有就空对象数组
                    //判断当前对象有没有下标hasOwnProPerty（）
                    if (obj.hasOwnProperty(key)) {
                        //如果当前obj有下标且obj[key]仍然是个对象，那继续吧obj[key]
                        //去重新进deepClone方法
                        if (obj[key] && typeof(obj[key]) == "object") {
                            objClone[key] = deepClone(obj[key])
                        } else {
                            objClone[key] = obj[key]
                        }
                    }
                }
            }
            return objClone
        }


        let a = {
            b: 1,
            b: {
                c: 2,
                d: {
                    a: [1, 2, 3, 4, 5, {
                        k: 1,
                        c: 0,
                        e: [
                            2, 3, 4, 5, 6, 6, 7, {
                                a: 1,
                                b: 2,
                                r: 1
                            }
                        ]
                    }]
                }
            }
        }

        // var b=JSON.parse(JSON.stringify(a));
        // b.b.d.a[5].c=1;
        // console.log(a);
        let xuexi = [];
        // xuexi=[1];
        function tuzi(index) {
            if (index < 2) {
                xuexi[index] = 1
            } else {
                xuexi[index] = xuexi[index - 1] + xuexi[index - 2]
            }
            if (index < 49) {
                tuzi(index + 1)
            }
            //[1,1]
        }
        tuzi(0)
        console.log(xuexi);
        //深拷贝 之递归拷贝
        var b = deepClone(a);
        b.b.c = 1;
        console.log(b);
        console.log(a);

        function deepClone(obj) {
            //  Array.isArray()
            //  判断是不是数组
            var objClone = Array.isArray(obj) ? [] : {};
            //判断当前obj是不是存在null undefind
            if (obj && typeof(obj) == "object") {
                //循环当前的对象
                for (let key in obj) {
                    //判断当前对象下有没有下标 如果没有就空对象数组
                    //判断当前对象有没有下标hasOwnProperty（）
                    if (obj.hasOwnProperty(key)) {
                        //如果当前obj有下标且obj[key]仍然是个对象，那继续把obj[key]
                        //去重新进deepClone方法
                        if (obj[key] && typeof(obj[key]) == "object") {
                            objClone[key] = deepClone(obj[key])
                        } else {
                            objClone[key] = obj[key]
                        }
                    }
                }
                return objClone
            }
        }

        let a = {
            a: 1,
            b: {
                c: 2,
                d: {
                    a: [
                        1, 2, 3, 4, 5, {
                            k: 1,
                            c: 0,
                            e: [
                                2, 5, 3, 6, 8, 4, {
                                    a: 1,
                                    b: 2,
                                    r: 1
                                }
                            ]
                        }
                    ]
                }
            }
        }

        // var b =JSON.parse(JSON.stringify(a));
        // b.b.d.a[5].c=1;
        // console.log(a);
        let xue = [];
        // xue=[1]
        function tu(index) {
            if (index < 2) {
                xue[index] = 1
            } else {
                xue[index] = xue[index - 1] + xue[index - 2]
            }
            if (index < 49) {
                tu(index + 1)
            }
        }
        //[1,1]
        tu(0)
        console.log(xue);
        //深拷贝 递归拷贝
        var b = deepClone(a);
        b.b.c = 1;
        console.log(b);
        console.log(a);

        function deepClone(obj) {
            // Array.isArray()
            // 判断是不是数组
            var objClone = Array.isArray(obj) ? [] : {};
            //判断当前obj是不是存在的 null undefind
            if (obj && typeof(obj) == "object") {
                //循环当前的对象
                for (let key in obj) {
                    //判断当前对象有没有下标 如果没有就空对象数组
                    //判断当前对象有没有下标hasOwnProperty()
                    if (obj.hasOwnProperty(key)) {
                        //如果当前obj有下标 且obj[key]仍然是个对象，那继续吧obj[key]
                        //去重新进deepClone方法
                        if (obj[key] && typeof(obj[key]) == "object") {
                            objClone[key] = deepClone(obj[key])
                        } else {
                            objClone[key] = obj[key]
                        }
                    }
                }
                return objClone
            }
        }
    </script>
</body>

</html>